The role of coordination analysis in software integration projects

Available for individual study only.What sort of component coordination strategies emerge in a software integration process? How can such strategies be discovered and further analysed? How close are they to the coordination component of the envisaged architectural model which was supposed to guide the integration process? This paper introduces a framework in which such questions can be discussed and illustrates its use by describing part of a real case-study. The approach is based on a methodology which enables semi-automatic discovery of coordination patterns from source code, combining generalized slicing techniques and graph manipulationThis research was partially supported by Fct in the context of the Mondrian project, under contract PTDC/EIA-CCO/108302/200

Conditions for up-down asymmetry in the core of tokamak equilibria

A local magnetic equilibrium solution is sought around the magnetic axis in order to identify the key parameters defining the magnetic-surface's up-down asymmetry in the core of tokamak plasmas. The asymmetry is found to be determined essentially by the ratio of the toroidal current density flowing on axis to the fraction of the external field's odd perturbation that manages to propagate from the plasma boundary into the core. The predictions are tested and illustrated first with an analytical Solovev equilibrium and then using experimentally relevant numerical equilibria. Hollow current-density distributions, and hence reverse magnetic shear, are seen to be crucial to bring into the core asymmetry values that are usually found only near the plasma edge.Comment: 6 pages, 2 figures, submitted for publicatio

Program slicing by calculation

Program slicing is a well known family of techniques used to identify code fragments which depend on or are depended upon specific program entities. They are particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, usually oriented towards the imperatice or object paradigms, are based on some sort of graph structure representing program dependencies. Slicing techniques amount, therefore, to (sophisticated) graph transversal algorithms. This paper proposes a completely different approach to the slicing problem for functional programs. Instead of extracting program information to build an underlying dependencies' structure, we resort to standard program calculation strategies, based on the so-called Bird-Meertens formalism. The slicing criterion is specified either as a projection or a hiding function which, once composed with the original program, leads to the identification of the intended slice. Going through a number of examples, the paper suggests this approach may be an interesting, even if not completely general, alternative to slicing functional programsFundação para a Ciência e a Tecnologia (FCT

On the discovery of business processes orchestration patterns

COORDINSPECTOR is a Software Tool aiming at extracting the coordination layer of a software system. Such a reverse engineering process provides a clear view of the actually invoked services as well as the logic behind such invocations. The analysis process is based on program slicing techniques and the generation of, System Dependence Graphs and Coordination Dependence Graphs. The tool analyzes Common Intermediate Language (CIL), the native language of the Microsoft .Net Frame- work, thus making suitable for processing systems developed in any .Net Framework compilable language. COORDINSPECTOR generates graphical representations of the coordination layer together with business process orchestrations specified in WS- BPEL 2.0

Extracting and verifying coordination models from source code

Current software development relies increasingly on non-trivial coordination logic for combining autonomous services often running on different platforms. As a rule, however, intypical non-trivial software systems, such a coordination layer is strongly weaved within the application at source code level. Therefore, its precise identification becomes a major methodological (and technical) problem which cannot be overestimated along any program understanding or refactoring process. Open access to source code, as granted in OSS certification, provides an opportunity for the development of methods and technologies to extract, from source code, the relevant coordination information. This paper is a step in this direction, combining a number of program analysis techniques to automatically recover coordination information from legacy code. Such information is then expressed as a model in Orc, a general purpose orchestration language

Slicing for architectural analysis

Current software development often relies on non trivial coordination logic for combining autonomous services, eventually running on different platforms. As a rule, however, such a coordination layer is strongly weaved within the application at source code level. Therefore, its precise identification becomes a major methodological (and technical) problem and a challenge to any program understanding or refactoring process. The approach introduced in this paper resorts to slicing techniques to extract coordination data from source code. Such data is captured in a specific dependency graph structure from which a coordination model can be recovered either in the form of an Orc specification or as a collection of code fragments corresponding to the identification of typical coordination patterns in the system. Tool support is also discussed.Fundação para a Ciência e a Tecnologia (FCT) - projeto Mondrian, PTDC/EIA-CCO/108302/200

Higher-order lazy functional slicing

Program slicing is a well known family of techniques intended to identify and isolate code fragments which depend on, or are depended upon, specific program entities. This is particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, and corresponding tools, target either the imperative or the object oriented paradigms, where program slices are computed with respect to a variable or a program statement. Taking a complementary point of view, this paper focuses on the slicing of higher-order functional programs under a lazy evaluation strategy. A prototype of a Haskell slicer, built as proof-of-concept for these ideas, is also introduced

Prototyping behavioural specifications in the net framework

Over the last decade, software architecture emerged as a critical design step in Software Engineering. This encompassed a shift from traditional programming towards the deployment and assembly of independent components. The specification of the overall system structure, on the one hand, and of the interactions patterns between its components, on the other, became a major concern for the working developer. Although a number of formalisms to express behaviour and supply the indispensable calculational power to reason about designs, are available, the task of deriving architectural designs on top of popular component platforms has remained largely informal. This paper introduces a systematic approach to derive, from behavioural specifications written in Ccs, the corresponding architectural skeletons in the Microsoft. Net framework in the form of executable C code. Such prototyping process is automated by means of a specific tool developed in Haskell

Numerical uncertainty and its implications

A scrutiny of the contributions of key mathematicians and scientists shows that there has been much controversy (throughout the development of mathematics and science) concerning the use of mathematics and the nature of mathematics too. In this work, we try to show that arithmetical operations of approximation lead to the existence of a numerical uncertainty, which is quantic, path dependent and also dependent on the number system used, with mathematical and physical implications. When we explore the algebraic equations for the fine structure constant, the conditions exposed in this work generate paradoxical physical conditions, where the solution to the paradox may be in the fact that the fine-structure constant is calculated through different ways in order to ob-tain the same value, but there is no relationship between the fundamental physical processes which underlie the calculations, since we are merely dealing with algebraic relations, despite the expressions having the same physi-cal dimensions.info:eu-repo/semantics/publishedVersio

New insights on biofilm antimicrobial strategies

Over the last few decades, the study of microbial biofilms has been gaining interest among the scientific community [...]info:eu-repo/semantics/publishedVersio